junebug12851 / pokered-mon-database

 * This module creates an in-memory Pokemon Database for Generation 1 Games

 * It uses a very small memory footprint and speedy-quick navigation

 * This happens through circular references which come with a lot of pitfalls

 *      * Make sure to only keep a single instance of this in memory, Javascript

 *        has a lot of issues with garbage collecting circular references.

 *      * If deep navigating the database, be very careful about not ending up

 *        in infinite loops.

 *      * You cannot use JSON.stringify or certain other tools, at least not

 *        without some careful prep work beforehand

 *

 * This was created initially for the Pokered Save Editor which works just fine

 * with the pitfalls of circular references but for other uses caution may need

 * to be taken.

 */

// Import Dependencies

const _ = require("lodash");

// Import Raw JSON Files

const itemsRaw = require("./data/items.json");

const movesRaw = require("./data/moves.json");

const pokemonRaw = require("./data/pokemon.json");

const typesRaw = require("./data/types.json");

// Class Constructor

// Initiate Array

const PokeredMonDB = exports.PokeredMonDB = function() {

    // Do initial build

    this.rebuild();

}

// Build or Rebuild database

// This should normally never need to be called manually

// and is provided for special edge cases. Keep in mind calling this again

// might create memory leaks in certain browsers due to circular references.

PokeredMonDB.prototype.rebuild = function() {

    // Rr-create array

    this.items = [];

    this.moves = [];

    this.pokemon = [];

    this.types = [];

    // Setup primary index to be the internal index number

    this._indexPrimary(this.itemsRaw, this.items, "ind");

    this._indexPrimary(this.movesRaw, this.moves, "ind");

    this._indexPrimary(this.pokemonRaw, this.pokemon, "ind");

    this._indexPrimary(this.typesRaw, this.types, "ind");

    // Add in aliases for names as-is

    this._indexSecondary(this.itemsRaw, this.items, "name", "ind");

    this._indexSecondary(this.movesRaw, this.moves, "name", "ind");

    this._indexSecondary(this.pokemonRaw, this.pokemon, "name", "ind");

    this._indexSecondary(this.typesRaw, this.types, "name", "ind");

    // Add in aliases for names in snake_case form

    this._indexSecondarySnake(this.itemsRaw, this.items, "name", "ind");

    this._indexSecondarySnake(this.movesRaw, this.moves, "name", "ind");

    this._indexSecondarySnake(this.pokemonRaw, this.pokemon, "name", "ind");

    this._indexSecondarySnake(this.typesRaw, this.types, "name", "ind");

    // Add in aliases prefixed

    this._indexSecondaryPrefix(this.itemsRaw, this.items, "tm", "ind");

    this._indexSecondaryPrefix(this.itemsRaw, this.items, "hm", "ind");

    this._indexSecondaryPrefix(this.movesRaw, this.moves, "tm", "ind");

    this._indexSecondaryPrefix(this.movesRaw, this.moves, "hm", "ind");

    this._indexSecondaryPrefix(this.pokemonRaw, this.pokemon, "pokedex", "ind");

    // Circular Link everything

    this._processAllItems();

    this._processAllMoves();

    this._processAllPokemon();

}

// Indexes all items by deep cloning each item and adding it to the object under key value

PokeredMonDB.prototype._indexPrimary = function(from, to, key) {

    this._iterate(from, function(entry) {

        to[entry[key]] = _.cloneDeep(entry);

    });

}

// Creates a 2nd index which just aliases the first index

PokeredMonDB.prototype._indexSecondary = function(from, to, key, origKey) {

    this._iterate(from, function(entry) {

        to[entry[key]] = to[entry[origKey]];

    });

}

// Creates a 2nd index snake_case'd which just aliases the first index

PokeredMonDB.prototype._indexSecondarySnake = function(from, to, key, origKey) {

    this._iterate(from, function(entry) {

        to[_.snakeCase(entry[key])] = to[entry[origKey]];

    });

}

// Creates a 2nd index prefixed which just aliases the first index

// Only creates alias if key exists

PokeredMonDB.prototype._indexSecondaryPrefix = function(from, to, key, origKey) {

    this._iterate(from, function(entry) {

        if(entry[key] !== undefined)

            to['' + key + entry[key]] = to[entry[origKey]];

    });

}

// This interlinks certain item meta-data to other database entries

PokeredMonDB.prototype._processAllItems = function() {

    this._iterate(this.items, function(value) {

        this._processPrimitiveEntry(value, "tm", "tm", "moves", this);

        this._processPrimitiveEntry(value, "hm", "hm", "moves", this);

    });

}

// This interlinks certain move meta-data to other database entries

// This interlinks certain pokemon meta-data to other database entries

PokeredMonDB.prototype._processAllPokemon = function() {

    this._iterate(this.pokemon, function(value) {

        this._iterate(value.moves, function(move) {

            this._processPrimitiveEntry(move, "move", "name", "moves", this);

        });

        this._processArrayEntry(value, "initial", "name", "moves", this);

        this._processArrayEntry(value, "tmHm", "_tm", "moves", this);

        this._processPrimitiveEntry(value, "type1", "name", "types", this);

        this._processPrimitiveEntry(value, "type2", "name", "types", this);

        this._processArrPrimEntry(value, "evolution", this._processEvolutionEntry);

    });

}

// This loops over an object or array if it's valid, checks each entry and calls a function

// if the entry is not defined. The function is binded to the class.

PokeredMonDB.prototype._iterate = function(v, fn) {

    _.each(v, function(value) {

        if(value === undefined)

        return fn.call(this, value);

    }.bind(this));

}

// This loops over an evolution pokemon database entry and proccesses it

PokeredMonDB.prototype._processEvolutionEntry = function(entry, value) {

    this._processPrimitiveEntry(entry, "item", "name", "items");

    // Intentional to simplify code below

    if(entry._toName !== undefined)

        return;

    this._processPrimitiveEntry(entry, "toName", "name", "pokemon");

    entry.toName.deEvolution = value;

}

// This loops over a simple array if it exists and inter-links valid elements to other data

PokeredMonDB.prototype._processArrayEntry = function(value, from, key, where) {

    if(value[from] !== undefined && value['_' + from] === undefined) {

        value['_' + from] = _.cloneDeep(value[from]);

        for(let i = 0; i < value[from].length; i++) {

            const val = value[from][i];

            value[from][i] = _.find(this[where], [key, val]);

        }

    }

}

// This interlinks primitive data to other data

PokeredMonDB.prototype._processPrimitiveEntry = function(value, from, key, where) {

    if(value[from] !== undefined && value["_" + from] === undefined) {

        value["_" + from] = value[from];

        value[from] = _.find(this[where], [key, value[from]]);

    }

}

// This interlinks a variable that could be an array or primitive and calls given function

// with each item and original object item came from

PokeredMonDB.prototype._processArrPrimEntry = function(value, from, fn) {

    if(Array.isArray(value[from])) {

        this._iterate(value[from], function(arrEntry) {

            fn.call(this, arrEntry, value);

        });

    }

    else if(value[from] !== undefined)

        fn.call(this, value[from], value);

}

// Add several ways to access the raw data, nothings duplicated because it's just all copying

// by reference

PokeredMonDB.itemsRaw = PokeredMonDB.prototype.itemsRaw = itemsRaw;

PokeredMonDB.movesRaw = PokeredMonDB.prototype.movesRaw = movesRaw;

PokeredMonDB.typesRaw = PokeredMonDB.prototype.typesRaw = typesRaw;

PokeredMonDB.pokemonRaw = PokeredMonDB.prototype.pokemonRaw = pokemonRaw;